package org.example.study.JUC.Thread;

import java.util.concurrent.*;

public class AlternatePrint extends Thread {
    private static Object lock = new Object();
    private static Integer counter = 1;
    private static Integer max = 10;
    private static boolean isOddTurn = true;

    // 启动两个线程，交替打印1-10
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Runnable task = () -> {
            while (true) {
                synchronized (lock) {
                    if (counter > max) {
                        break;
                    }
                    boolean isOddThread = Thread.currentThread().getName().contains("奇数");
                    if ((isOddTurn && isOddThread) || (!isOddTurn && !isOddThread)) {
                        System.out.println(Thread.currentThread().getName() + ": " + counter);
                        counter++;
                        lock.notifyAll();
                        isOddTurn = !isOddTurn;
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        };
        new Thread(task, "奇数线程").start();
        new Thread(task, "偶数线程").start();

        // 方式一  继承线程
        class MyThread extends Thread {
            @Override
            public void run() {
                System.out.println("111111111111111111");
            }
        }

        // 方式二 实现Runnable
        class MyRunnable implements Runnable {
            @Override
            public void run() {
                System.out.println("222222222222222222");
            }
        }
        // 方式三 实现Callable（有返回，方法改为call）
        class MyCallable implements Callable<Integer> {
            @Override
            public Integer call() throws Exception {
                System.out.println("333333333333333333333333333");
                return 1+2;
            }
        }
        // 方式四 线程池 使用ExecutorService  Executors 工厂方法
        /** 优点
        使用简单：一行代码即可创建常见类型的线程池
        快速上手：适合初学者和简单应用场景
        缺点
        灵活性不足：无法自定义核心参数
        潜在风险：
        newFixedThreadPool 和 newSingleThreadExecutor 使用无界队列，可能导致内存溢出
        newCachedThreadPool 可能创建过多线程，导致系统资源耗尽
         **/
        ExecutorService executor = Executors.newFixedThreadPool(5);
        executor.execute(() -> {
            System.out.println("44444444444444");
        });
        Future<Integer> future = executor.submit(() -> 1+3);

        //线程池 自定义ThreadPoolExecutor 直接创建
        /**
         * 优点
         完全可控：可以精确控制所有参数
         安全性高：可以设置合理的队列大小和拒绝策略
         适应性强：可根据具体业务需求定制
         缺点
         复杂度高：需要理解更多参数含义
         配置繁琐：需要手动设置多个参数
         */
        ThreadPoolExecutor customizeExecutor = new ThreadPoolExecutor(
                5,                          // corePoolSize
                10,                         // maximumPoolSize
                60L,                        // keepAliveTime
                TimeUnit.SECONDS,           // unit
                new LinkedBlockingQueue<>(100), // workQueue
                Executors.defaultThreadFactory(), // threadFactory
                new ThreadPoolExecutor.AbortPolicy() // handler
        );

        //方式五 使用 CompletableFuture
        CompletableFuture.runAsync(() -> {
            System.out.println("55555555555555");
        });

        CompletableFuture.supplyAsync(() -> 1+4);

        MyThread myThread = new MyThread();
        myThread.start();
        myThread.interrupt();
        Thread thread = new Thread(new MyRunnable());
        thread.start();
        thread.interrupt();
        Future<Integer> future1 = executor.submit(new MyCallable());
        System.out.println(future1.get()+ future.get());

        /**
         44444444444444
         55555555555555
         111111111111111111
         奇数线程: 1
         偶数线程: 2
         奇数线程: 3
         偶数线程: 4
         奇数线程: 5
         偶数线程: 6
         奇数线程: 7
         偶数线程: 8
         奇数线程: 9
         偶数线程: 10
         222222222222222222
         333333333333333333333333333

         **/
    }
}

